/*!
 * \file test_fmtlib_simple.cpp
 * \project WonderTrader
 * 
 * \brief fmt格式化库简化测试套件
 * 
 * \details 测试fmtlib.h封装的fmt格式化功能的基本特性：
 *          - 基本格式化功能
 *          - 数值格式化
 *          - 字符串处理
 *          - 中文字符支持
 *          - 简单的性能验证
 */

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "../../src/Share/fmtlib.h"
#include <string>
#include <vector>
#include <chrono>
#include <sstream>
#include <iomanip>

/*!
 * \brief fmt格式化库简化测试套件
 * 
 * \details 测试fmt库的核心格式化功能：
 *          - 基本字符串格式化
 *          - 数值类型格式化
 *          - 中文字符处理
 *          - 基本性能特性
 */
class FmtLibSimpleTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 测试前准备
        test_int = 42;
        test_double = 3.14159;
        test_string = "Hello, World!";
        test_chinese = "你好，世界！";
        test_price = 123.456789;
    }
    
    void TearDown() override {
        // 测试后清理
    }
    
    // 测试数据
    int test_int;
    double test_double;
    std::string test_string;
    std::string test_chinese;
    double test_price;
};

// ========== 基本格式化测试 ==========

/*!
 * \brief 测试基本的format函数
 */
TEST_F(FmtLibSimpleTest, TestBasicFormat) {
    // 测试简单字符串格式化
    std::string result = fmt::format("Hello, {}!", "fmt");
    EXPECT_EQ(result, "Hello, fmt!");
    
    // 测试数字格式化
    result = fmt::format("Number: {}", test_int);
    EXPECT_EQ(result, "Number: 42");
    
    // 测试多参数格式化
    result = fmt::format("{} + {} = {}", 1, 2, 3);
    EXPECT_EQ(result, "1 + 2 = 3");
}

/*!
 * \brief 测试位置参数格式化
 */
TEST_F(FmtLibSimpleTest, TestPositionalArguments) {
    // 测试位置参数
    std::string result = fmt::format("{1} {0}", "World", "Hello");
    EXPECT_EQ(result, "Hello World");
    
    // 测试重复使用参数
    result = fmt::format("{0} {1} {0}", "A", "B");
    EXPECT_EQ(result, "A B A");
}

/*!
 * \brief 测试数值格式化
 */
TEST_F(FmtLibSimpleTest, TestNumericFormatting) {
    // 测试整数格式化
    std::string result = fmt::format("十进制: {}, 十六进制: {:x}", 255, 255);
    EXPECT_EQ(result, "十进制: 255, 十六进制: ff");
    
    // 测试浮点数精度
    result = fmt::format("价格: {:.2f}", test_price);
    EXPECT_EQ(result, "价格: 123.46");
    
    // 测试科学计数法
    result = fmt::format("科学计数法: {:.2e}", test_price);
    EXPECT_EQ(result, "科学计数法: 1.23e+02");
}

/*!
 * \brief 测试字符串格式化和对齐
 */
TEST_F(FmtLibSimpleTest, TestStringFormatting) {
    // 测试字符串截断
    std::string result = fmt::format("{:.5}", "Hello, World!");
    EXPECT_EQ(result, "Hello");
    
    // 测试左对齐
    result = fmt::format("'{:<10}'", "left");
    EXPECT_EQ(result, "'left      '");
    
    // 测试右对齐
    result = fmt::format("'{:>10}'", "right");
    EXPECT_EQ(result, "'     right'");
    
    // 测试居中对齐
    result = fmt::format("'{:^10}'", "center");
    EXPECT_EQ(result, "'  center  '");
}

/*!
 * \brief 测试中文字符处理
 */
TEST_F(FmtLibSimpleTest, TestChineseCharacters) {
    // 测试中文字符串格式化
    std::string result = fmt::format("消息: {}", test_chinese);
    EXPECT_EQ(result, "消息: 你好，世界！");
    
    // 测试中文和英文混合
    result = fmt::format("{} - {}", test_chinese, test_string);
    EXPECT_EQ(result, "你好，世界！ - Hello, World!");
    
    // 测试中文数值格式化
    result = fmt::format("价格：￥{:.2f}元", test_price);
    EXPECT_EQ(result, "价格：￥123.46元");
}

// ========== printf风格格式化测试 ==========

/*!
 * \brief 测试sprintf函数
 */
TEST_F(FmtLibSimpleTest, TestSprintfFormatting) {
    // 测试基本sprintf
    std::string result = fmt::sprintf("Hello, %s!", "sprintf");
    EXPECT_EQ(result, "Hello, sprintf!");
    
    // 测试数值格式化
    result = fmt::sprintf("整数: %d, 浮点数: %.2f", test_int, test_double);
    EXPECT_EQ(result, "整数: 42, 浮点数: 3.14");
    
    // 测试十六进制格式化
    result = fmt::sprintf("十六进制: 0x%x", 255);
    EXPECT_EQ(result, "十六进制: 0xff");
}

/*!
 * \brief 测试printf风格的宽度和精度
 */
TEST_F(FmtLibSimpleTest, TestSprintfWidthPrecision) {
    // 测试字段宽度
    std::string result = fmt::sprintf("'%10s'", "test");
    EXPECT_EQ(result, "'      test'");
    
    // 测试左对齐
    result = fmt::sprintf("'%-10s'", "test");
    EXPECT_EQ(result, "'test      '");
    
    // 测试数值宽度和精度
    result = fmt::sprintf("'%10.2f'", test_price);
    EXPECT_EQ(result, "'    123.46'");
    
    // 测试零填充
    result = fmt::sprintf("'%08d'", test_int);
    EXPECT_EQ(result, "'00000042'");
}

// ========== 错误处理和边界条件测试 ==========

/*!
 * \brief 测试空字符串和特殊字符
 */
TEST_F(FmtLibSimpleTest, TestEmptyAndSpecialStrings) {
    // 测试空字符串
    std::string result = fmt::format("空字符串: '{}'", "");
    EXPECT_EQ(result, "空字符串: ''");
    
    // 测试特殊字符
    result = fmt::format("特殊字符: '{}'", "\n\t\r");
    EXPECT_EQ(result, "特殊字符: '\n\t\r'");
}

/*!
 * \brief 测试大数值格式化
 */
TEST_F(FmtLibSimpleTest, TestLargeNumbers) {
    // 测试大整数
    long long large_number = 1234567890LL;
    std::string result = fmt::format("大整数: {}", large_number);
    EXPECT_EQ(result, "大整数: 1234567890");
    
    // 测试科学计数法大数
    double large_double = 1.23e15;
    result = fmt::format("大浮点数: {:.2e}", large_double);
    EXPECT_EQ(result, "大浮点数: 1.23e+15");
    
    // 测试负数
    result = fmt::format("负数: {}, {:.2f}", -test_int, -test_double);
    EXPECT_EQ(result, "负数: -42, -3.14");
}

/*!
 * \brief 测试格式化性能
 */
TEST_F(FmtLibSimpleTest, TestFormattingPerformance) {
    const int iterations = 10000;
    
    // 测试fmt::format性能
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        std::string result = fmt::format("测试 {} - {:.2f}", i, test_double);
        (void)result; // 避免编译器优化
    }
    auto fmt_duration = std::chrono::high_resolution_clock::now() - start;
    
    // 测试std::ostringstream性能（对比）
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        std::ostringstream oss;
        oss << "测试 " << i << " - " << std::fixed << std::setprecision(2) << test_double;
        std::string result = oss.str();
        (void)result; // 避免编译器优化
    }
    auto stream_duration = std::chrono::high_resolution_clock::now() - start;
    
    // fmt应该比ostringstream更快或相当
    auto fmt_ms = std::chrono::duration_cast<std::chrono::milliseconds>(fmt_duration).count();
    auto stream_ms = std::chrono::duration_cast<std::chrono::milliseconds>(stream_duration).count();
    
    std::cout << "fmt格式化性能: " << fmt_ms << "ms" << std::endl;
    std::cout << "stream格式化性能: " << stream_ms << "ms" << std::endl;
    
    // 性能测试不应该失败，只是记录结果
    EXPECT_GE(fmt_ms, 0);
    EXPECT_GE(stream_ms, 0);
}

/*!
 * \brief 测试边界条件和异常情况
 */
TEST_F(FmtLibSimpleTest, TestBoundaryConditions) {
    // 测试零值
    std::string result = fmt::format("零值: {}, {:.2f}", 0, 0.0);
    EXPECT_EQ(result, "零值: 0, 0.00");
    
    // 测试极小值
    result = fmt::format("极小值: {:.10f}", 1e-10);
    EXPECT_EQ(result, "极小值: 0.0000000001");
    
    // 测试布尔值
    result = fmt::format("布尔值: {}, {}", true, false);
    EXPECT_EQ(result, "布尔值: true, false");
}

/*!
 * \brief 测试容器和数组格式化
 */
TEST_F(FmtLibSimpleTest, TestContainerFormatting) {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // 手动格式化数组（fmt可能不直接支持容器）
    std::string result = fmt::format("数组大小: {}", numbers.size());
    EXPECT_EQ(result, "数组大小: 5");
    
    // 格式化数组元素
    result = fmt::format("第一个元素: {}, 最后一个元素: {}", 
                        numbers.front(), numbers.back());
    EXPECT_EQ(result, "第一个元素: 1, 最后一个元素: 5");
}

/*!
 * \brief 测试类型安全特性
 */
TEST_F(FmtLibSimpleTest, TestTypeSafety) {
    // fmt库应该能正确处理不同类型
    std::string result;
    
    // 整数类型
    int8_t small_int = 127;
    result = fmt::format("小整数: {}", small_int);
    EXPECT_EQ(result, "小整数: 127");
    
    // 无符号类型
    uint32_t unsigned_val = 4294967295U;
    result = fmt::format("无符号数: {}", unsigned_val);
    EXPECT_EQ(result, "无符号数: 4294967295");
    
    // 字符类型
    char ch = 'A';
    result = fmt::format("字符: {}", ch);
    EXPECT_EQ(result, "字符: A");
}

/*!
 * \brief 测试内存使用
 */
TEST_F(FmtLibSimpleTest, TestMemoryUsage) {
    // 测试大字符串格式化
    std::string large_string(1000, 'A');
    std::string result = fmt::format("大字符串长度: {}, 前10个字符: {:.10}", 
                                   large_string.length(), large_string);
    
    EXPECT_TRUE(result.find("大字符串长度: 1000") == 0);
    EXPECT_TRUE(result.find("AAAAAAAAAA") != std::string::npos);
    
    // 测试多次格式化不会内存泄漏
    for (int i = 0; i < 1000; ++i) {
        std::string temp = fmt::format("迭代 {} - {}", i, large_string.substr(0, 10));
        EXPECT_FALSE(temp.empty());
    }
} 